home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / IEditor / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-17  |  51.9 KB  |  2,444 lines
  1. /// Include
  2. #define INTUI_V36_NAMES_ONLY
  3. #define ASL_V38_NAMES_ONLY
  4. #define CATCOMP_NUMBERS
  5.  
  6. #include <exec/memory.h>                // exec
  7. #include <exec/lists.h>
  8. #include <exec/libraries.h>
  9. #include <exec/execbase.h>
  10. #include <intuition/intuition.h>        // intuition
  11. #include <dos/dos.h>                    // dos
  12. #include <libraries/gadtools.h>         // libraries
  13. #include <libraries/asl.h>
  14. #include <libraries/iffparse.h>
  15. #include <iffp/ilbm.h>                  // iffp
  16. #include <clib/exec_protos.h>           // protos
  17. #include <clib/intuition_protos.h>
  18. #include <clib/graphics_protos.h>
  19. #include <clib/dos_protos.h>
  20. #include <clib/iffparse_protos.h>
  21. #include <clib/asl_protos.h>
  22. #include <clib/locale_protos.h>
  23. #include <clib/gadtools_protos.h>
  24. #include <pragmas/exec_pragmas.h>       // pragmas
  25. #include <pragmas/intuition_pragmas.h>
  26. #include <pragmas/graphics_pragmas.h>
  27. #include <pragmas/dos_pragmas.h>
  28. #include <pragmas/locale_pragmas.h>
  29. #include <pragmas/asl_pragmas.h>
  30. #include <pragmas/reqtools_pragmas.h>
  31. #include <pragmas/gadtools_pragmas.h>
  32. #include <pragmas/iffparse_pragmas.h>
  33.  
  34. #include <stdarg.h>
  35. #include <string.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38.  
  39. #include "DEV_IE:defs.h"
  40. #include "DEV_IE:GUI.h"
  41. #include "DEV_IE:GUI_locale.h"
  42. ///
  43. /// Prototipi
  44. static void             StaccaMenuList( void );
  45. static void             AttaccaMenuList( void );
  46. static void             StaccaItemList( void );
  47. static void             AttaccaItemList( void );
  48. static void             StaccaSubList( void );
  49. static void             AttaccaSubList( void );
  50. static struct MenuTitle *GetMenuSel( void );
  51. static struct _MenuItem *GetItemSel( void );
  52. static struct MenuSub   *GetSubSel( void );
  53. static void             OpenMutualExclude( struct MinList *, struct _MenuItem * );
  54. static void             MX_StaccaExcList( void );
  55. static void             MX_AttaccaExcList( void );
  56. static void             MX_StaccaIncList( void );
  57. static void             MX_AttaccaIncList( void );
  58. static void             ME_AttivaTitle( void );
  59. static void             ME_AttivaItem( void );
  60. static void             ME_AttivaSub( void );
  61. static void             ME_DisattivaTitle( void );
  62. static void             ME_DisattivaItem( void );
  63. static void             ME_DisattivaSub( void );
  64. static void             AggiornaItemSub( void );
  65. static void             AggiornaSub( void );
  66. static void             ME_EditTitle( struct MenuTitle * );
  67. static void             ME_EditItem( struct _MenuItem * );
  68. static void             ME_AttivaChecks( void );
  69. static void             MEd_BarLabel( void );
  70. static void             MEd_SetChecks( struct _MenuItem * );
  71. static void             AttaccaImgList( void );
  72. static void             StaccaImgList( void );
  73. static void             AnalyseBitmap( struct ImageNode * );
  74. static void             ClrImgSpace( void );
  75. static void             HandleImgBank( void );
  76. ///
  77. /// Dati
  78. TEXT    Bar_txt[] = "-------------------------";
  79.  
  80. TEXT    ImageFile[30];
  81. TEXT    initial_imgdrawer[300];
  82. TEXT    Img_Pattern[60] = "(#?.iff|#?.ilbm|#?.pic)";
  83.  
  84. static UWORD    LastTitle, LastItem, LastSub;
  85. static WORD     VarA, VarB;
  86.  
  87. static BOOL     TitleAct, ItemAct, SubAct;
  88.  
  89. static struct MinList   Exc_List, Inc_List, Other_List;
  90. ///
  91.  
  92.  
  93. //      Varie
  94. /// Funzioni sui nodi
  95. void NodeUp( APTR node )
  96. {
  97.     struct Node *pred, *succ;
  98.  
  99.     succ = ((struct Node *)node)->ln_Succ;
  100.     pred = ((struct Node *)node)->ln_Pred;
  101.  
  102.     if( pred->ln_Pred ) {
  103.     pred->ln_Succ = succ;
  104.     succ->ln_Pred = pred;
  105.     succ = pred->ln_Pred;
  106.     succ->ln_Succ = node;
  107.     pred->ln_Pred = node;
  108.     ((struct Node *)node)->ln_Succ = pred;
  109.     ((struct Node *)node)->ln_Pred = succ;
  110.  
  111.     }
  112. }
  113.  
  114. void NodeDown( APTR node )
  115. {
  116.     struct Node *pred, *succ;
  117.  
  118.     succ = ((struct Node *)node)->ln_Succ;
  119.  
  120.     if( succ->ln_Succ ) {
  121.     pred = ((struct Node *)node)->ln_Pred;
  122.     pred->ln_Succ = succ;
  123.     succ->ln_Pred = pred;
  124.     pred = succ->ln_Succ;
  125.     pred->ln_Pred = node;
  126.     succ->ln_Succ = node;
  127.     ((struct Node *)node)->ln_Succ = pred;
  128.     ((struct Node *)node)->ln_Pred = succ;
  129.     }
  130. }
  131. ///
  132. /// GetImgFile
  133. BOOL GetImgFile( BOOL savemode, STRPTR titolo, ULONG titn, STRPTR ext )
  134. {
  135.     UBYTE   *ptr, ch;
  136.     BOOL     ok;
  137.     struct   FileRequester *req;
  138.  
  139.     if(( ext ) && ( ImageFile[0] )) {
  140.     ptr = ImageFile;
  141.  
  142.     do {
  143.         ch = *ptr++;
  144.     } while(( ch != '.' ) && ( ch != '\0' ));
  145.  
  146.     if( ch == '\0' ) {
  147.         ptr--;
  148.         *ptr++ = '.';
  149.     }
  150.  
  151.     while( *ext != '\0' )
  152.         *ptr++ = *ext++;
  153.     *ptr = '\0';
  154.     }
  155.  
  156.     if( LocaleBase )
  157.     titolo = GetCatalogStr( Catalog, titn, titolo );
  158.  
  159.     if( req = AllocAslRequest( ASL_FileRequest, NULL )) {
  160.  
  161.     if ( ok = AslRequestTags( req, ASLFR_DoPatterns,     TRUE,
  162.                   ASLFR_InitialHeight,  Scr->Height - 40,
  163.                   ASLFR_TitleText,      titolo,
  164.                   ASLFR_InitialFile,    ImageFile,
  165.                   ASLFR_InitialDrawer,  initial_imgdrawer,
  166.                   ASLFR_InitialPattern, Img_Pattern,
  167.                   ASLFR_Window,         BackWnd,
  168.                   ASLFR_DoSaveMode,     (ULONG)savemode,
  169.                   TAG_END )) {
  170.  
  171.         strcpy( ImageFile, req->fr_File );
  172.         strcpy( initial_imgdrawer, req->fr_Drawer );
  173.         strcpy( allpath, req->fr_Drawer );
  174.         strcpy( Img_Pattern, req->fr_Pattern );
  175.         AddPart( allpath, req->fr_File, 1024 );
  176.  
  177.     }
  178.  
  179.     FreeAslRequest( req );
  180.  
  181.     } else {
  182.     Stat( CatCompArray[ ERR_NOASL ].cca_Str, TRUE, 0 );
  183.     ok = FALSE;
  184.     }
  185.  
  186.     return( ok );
  187. }
  188. ///
  189.  
  190. //      Menu Editor
  191. /// Menu Editor
  192. BOOL ME_IExcludeClicked( void )
  193. {
  194.     struct MenuTitle   *menu;
  195.  
  196.     menu = GetMenuSel();
  197.  
  198.     StaccaItemList;
  199.     OpenMutualExclude( &menu->mt_Items, GetItemSel() );
  200.     AttaccaItemList();
  201.  
  202.     return( TRUE );
  203. }
  204.  
  205. BOOL ME_SExcludeClicked( void )
  206. {
  207.     struct _MenuItem   *item;
  208.  
  209.     item = GetItemSel();
  210.  
  211.     StaccaSubList();
  212.     OpenMutualExclude( &item->min_Subs, (struct _MenuItem *)GetSubSel() );
  213.     AttaccaSubList();
  214.  
  215.     return( TRUE );
  216. }
  217.  
  218. BOOL MenuEdCloseWindow( void )
  219. {
  220.     return( FALSE );
  221. }
  222.  
  223. BOOL ME_OkClicked( void )
  224. {
  225.     return( FALSE );
  226. }
  227.  
  228. BOOL MenuEdIntuiTicks( void )
  229. {
  230.     Timer += 1;
  231.     return( TRUE );
  232. }
  233.  
  234. BOOL MenuEdMenued( void )
  235. {
  236.     int                 ret;
  237.     struct MenuTitle   *menu;
  238.     struct _MenuItem   *item;
  239.  
  240.     LockAllWindows();
  241.  
  242.     List2Tag[1] = List2Tag[3] = List2Tag2[1] = List2Tag2[3] = List2Tag3[1] = List2Tag3[3] = 0;
  243.  
  244.     AddHead((struct List *)&IE.Img_List, &NoneNode );
  245.  
  246.     LayoutWindow( MenuEdWTags );
  247.     ret = OpenMenuEdWindow();
  248.     PostOpenWindow( MenuEdWTags );
  249.  
  250.     if( ret ) {
  251.     DisplayBeep( Scr );
  252.     } else {
  253.  
  254.     MenuEdGadgets[ GD_ME_Test ]->Activation |= GACT_TOGGLESELECT;
  255.  
  256.     TitleAct = SubAct = ItemAct = TRUE;
  257.  
  258.     LastTitle = LastItem = LastSub = -1;
  259.  
  260.     if( IE.win_info->wi_NumMenus ) {
  261.         ME_AttivaTitle();
  262.         AttaccaMenuList();
  263.  
  264.         menu = GetMenuSel();
  265.  
  266.         if( menu->mt_NumItems ) {
  267.         ME_AttivaItem();
  268.         AttaccaItemList();
  269.  
  270.         item = GetItemSel();
  271.  
  272.         if( item->min_NumSubs ) {
  273.             ME_AttivaSub();
  274.             AttaccaSubList();
  275.         }
  276.         }
  277.     }
  278.  
  279.     Timer = 0;
  280.  
  281.     while( ReqHandle( MenuEdWnd, HandleMenuEdIDCMP ));
  282.     }
  283.  
  284.     CloseMenuEdWindow();
  285.  
  286.     RemHead((struct List *)&IE.Img_List );
  287.  
  288.     if( IE.win_info->wi_NumMenus )
  289.     IE.win_info->wi_IDCMP |= IDCMP_MENUPICK;
  290.  
  291.     UnlockAllWindows();
  292.  
  293.     return( TRUE );
  294. }
  295.  
  296. BOOL ME_TitleClicked( void )
  297. {
  298.     UWORD   old = LastTitle;
  299.  
  300.     LastTitle = List2Tag[1] = List2Tag[3] = MenuEdMsg.Code;
  301.  
  302.     if( old == LastTitle ) {
  303.     if( Timer < 3 )
  304.         ME_EditTitle( GetMenuSel() );
  305.     } else {
  306.     List2Tag2[1] = List2Tag2[3] = 0;
  307.     AggiornaItemSub();
  308.     }
  309.  
  310.     LastItem = LastSub = -1;
  311.  
  312.     Timer = 0;
  313.  
  314.     return( TRUE );
  315. }
  316.  
  317. BOOL ME_ItemClicked( void )
  318. {
  319.     UWORD       old = LastItem;
  320.  
  321.     LastItem = List2Tag2[1] = List2Tag2[3] = MenuEdMsg.Code;
  322.  
  323.     if( old == LastItem ) {
  324.     if( Timer < 3 )
  325.         ME_EditItem( GetItemSel() );
  326.     } else {
  327.     List2Tag3[1] = List2Tag3[3] = 0;
  328.     AggiornaSub();
  329.     }
  330.  
  331.     LastTitle = LastSub = -1;
  332.  
  333.     Timer = 0;
  334.  
  335.     return( TRUE );
  336. }
  337.  
  338. BOOL ME_SubClicked( void )
  339. {
  340.     UWORD       old = LastSub;
  341.  
  342.     LastSub = List2Tag3[1] = List2Tag3[3] = MenuEdMsg.Code;
  343.  
  344.     LastTitle = LastItem = -1;
  345.  
  346.     if( Timer < 3 ) {
  347.     if( LastSub == old ) {
  348.         ME_EditItem( (struct _MenuItem *)GetSubSel() );
  349.     }
  350.     }
  351.  
  352.     Timer = 0;
  353.  
  354.     return( TRUE );
  355. }
  356.  
  357. BOOL ME_TNuovoClicked( void )
  358. {
  359.     struct MenuTitle   *menu;
  360.     int                 ret;
  361.  
  362.     if( menu = AllocObject( IE_MENUTITLE )) {
  363.  
  364.     buffer4 = menu;
  365.  
  366.     LayoutWindow( MEEditWTags );
  367.     ret = OpenMEEditWindow();
  368.     PostOpenWindow( MEEditWTags );
  369.  
  370.     if( ret ) {
  371.         FreeObject( menu, IE_MENUTITLE );
  372.         DisplayBeep( Scr );
  373.     } else {
  374.  
  375.         RetCode = 0;
  376.  
  377.         do {
  378.         WaitPort( MEEditWnd->UserPort );
  379.         HandleMEEditIDCMP();
  380.         } while(!( RetCode ));
  381.  
  382.         strcpy( menu->mt_Text, GetString( MEEditGadgets[ GD_MEd_Txt ]) );
  383.         strcpy( menu->mt_Label, GetString( MEEditGadgets[ GD_MEd_Label ]) );
  384.  
  385.         if( RetCode < 0 ) {
  386.  
  387.         StaccaMenuList();
  388.  
  389.         if(!( IE.win_info->wi_NumMenus ))
  390.             ME_AttivaTitle();
  391.  
  392.         List2Tag[1] = List2Tag[3] = IE.win_info->wi_NumMenus;
  393.         IE.win_info->wi_NumMenus += 1;
  394.  
  395.         AddTail(( struct List * )&IE.win_info->wi_Menus, (struct Node *)menu );
  396.  
  397.         AttaccaMenuList();
  398.         AggiornaItemSub();
  399.  
  400.         IE.flags &= ~SALVATO;
  401.  
  402.         LastTitle = -1;
  403.  
  404.         } else {
  405.         FreeObject( menu, IE_MENUTITLE );
  406.         }
  407.     }
  408.  
  409.     CloseMEEditWindow();
  410.  
  411.     } else {
  412.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  413.     }
  414.  
  415.     return( TRUE );
  416. }
  417.  
  418. BOOL ME_TSuClicked( void )
  419. {
  420.     if( List2Tag[1] ) {
  421.  
  422.     StaccaMenuList();
  423.  
  424.     NodeUp( GetMenuSel() );
  425.  
  426.     List2Tag[1] -= 1;
  427.     List2Tag[3] = List2Tag[1];
  428.  
  429.     AttaccaMenuList();
  430.  
  431.     IE.flags &= ~SALVATO;
  432.     }
  433.  
  434.     return( TRUE );
  435. }
  436.  
  437. BOOL ME_TGiuClicked( void )
  438. {
  439.     if( List2Tag[1] < IE.win_info->wi_NumMenus - 1 ) {
  440.  
  441.     StaccaMenuList();
  442.  
  443.     NodeDown( GetMenuSel() );
  444.  
  445.     List2Tag[1] += 1;
  446.     List2Tag[3] = List2Tag[1];
  447.  
  448.     AttaccaMenuList();
  449.  
  450.     IE.flags &= ~SALVATO;
  451.     }
  452.  
  453.     return( TRUE );
  454. }
  455.  
  456. BOOL ME_ISuClicked( void )
  457. {
  458.     if( List2Tag2[1] ) {
  459.  
  460.     StaccaItemList();
  461.  
  462.     NodeUp( GetItemSel() );
  463.  
  464.     List2Tag2[1] -= 1;
  465.     List2Tag2[3] = List2Tag2[1];
  466.  
  467.     AttaccaItemList();
  468.  
  469.     IE.flags &= ~SALVATO;
  470.     }
  471.  
  472.     return( TRUE );
  473. }
  474.  
  475. BOOL ME_IGiuClicked( void )
  476. {
  477.     struct MenuTitle   *menu;
  478.  
  479.     menu = GetMenuSel();
  480.  
  481.     if( List2Tag2[1] < menu->mt_NumItems - 1 ) {
  482.  
  483.     StaccaItemList();
  484.  
  485.     NodeDown( GetItemSel() );
  486.  
  487.     List2Tag2[1] += 1;
  488.     List2Tag2[3] = List2Tag2[1];
  489.  
  490.     AttaccaItemList();
  491.  
  492.     IE.flags &= ~SALVATO;
  493.     }
  494.  
  495.     return( TRUE );
  496. }
  497.  
  498. BOOL ME_SSuClicked( void )
  499. {
  500.     if( List2Tag3[1] ) {
  501.  
  502.     StaccaSubList();
  503.  
  504.     NodeUp( GetSubSel() );
  505.  
  506.     List2Tag3[1] -= 1;
  507.     List2Tag3[3] = List2Tag3[1];
  508.  
  509.     AttaccaSubList();
  510.  
  511.     IE.flags &= ~SALVATO;
  512.     }
  513.  
  514.     return( TRUE );
  515. }
  516.  
  517. BOOL ME_SGiuClicked( void )
  518. {
  519.     struct _MenuItem   *item;
  520.  
  521.     item = GetItemSel();
  522.  
  523.     if( List2Tag3[1] < item->min_NumSubs - 1 ) {
  524.  
  525.     StaccaSubList();
  526.  
  527.     NodeDown( GetSubSel() );
  528.  
  529.     List2Tag3[1] += 1;
  530.     List2Tag3[3] = List2Tag3[1];
  531.  
  532.     AttaccaSubList();
  533.  
  534.     IE.flags &= ~SALVATO;
  535.     }
  536.  
  537.     return( TRUE );
  538. }
  539.  
  540. BOOL ME_TDelClicked( void )
  541. {
  542.     struct MenuTitle   *menu;
  543.  
  544.     if( menu = GetMenuSel() ) {
  545.  
  546.     StaccaMenuList();
  547.  
  548.     Remove((struct Node *)menu );
  549.  
  550.     FreeObject( menu, IE_MENUTITLE );
  551.  
  552.     IE.win_info->wi_NumMenus -= 1;
  553.  
  554.     if( List2Tag[1] ) {
  555.         List2Tag[1] -= 1;
  556.         List2Tag[3] = List2Tag[1];
  557.     }
  558.  
  559.     AttaccaMenuList();
  560.     AggiornaItemSub();
  561.  
  562.     if(!( IE.win_info->wi_NumMenus )) {
  563.         ME_DisattivaTitle();
  564.         ME_DisattivaItem();
  565.         ME_DisattivaSub();
  566.     }
  567.  
  568.     IE.flags &= ~SALVATO;
  569.     }
  570.  
  571.     return( TRUE );
  572. }
  573.  
  574. BOOL ME_IDelClicked( void )
  575. {
  576.     struct _MenuItem   *item;
  577.     struct MenuTitle   *menu;
  578.  
  579.     if( item = GetItemSel() ) {
  580.  
  581.     StaccaItemList();
  582.  
  583.     Remove((struct Node *)item );
  584.  
  585.     FreeObject( item, IE_MENUITEM );
  586.  
  587.     menu = GetMenuSel();
  588.     menu->mt_NumItems -= 1;
  589.  
  590.     if( List2Tag2[1] ) {
  591.         List2Tag2[1] -= 1;
  592.         List2Tag2[3] = List2Tag2[1];
  593.     }
  594.  
  595.     AttaccaItemList();
  596.     AggiornaSub();
  597.  
  598.     if(!( menu->mt_NumItems )) {
  599.         ME_DisattivaItem();
  600.         ME_DisattivaSub();
  601.     }
  602.  
  603.     IE.flags &= ~SALVATO;
  604.     }
  605.  
  606.     return( TRUE );
  607. }
  608.  
  609. BOOL ME_SDelClicked( void )
  610. {
  611.     struct _MenuItem   *item;
  612.     struct MenuSub     *sub;
  613.  
  614.     if( sub = GetSubSel() ) {
  615.  
  616.     StaccaSubList();
  617.  
  618.     Remove((struct Node *)sub );
  619.     FreeObject( sub, IE_MENUSUB );
  620.  
  621.     item = GetItemSel();
  622.     item->min_NumSubs -= 1;
  623.  
  624.     if( List2Tag3[1] ) {
  625.         List2Tag3[1] -= 1;
  626.         List2Tag3[3] = List2Tag3[1];
  627.     }
  628.  
  629.     AttaccaSubList();
  630.  
  631.     if(!( item->min_NumSubs ))
  632.         ME_DisattivaSub();
  633.  
  634.     IE.flags &= ~SALVATO;
  635.     }
  636.  
  637.     return( TRUE );
  638. }
  639.  
  640. BOOL ME_SNuovoClicked( void )
  641. {
  642.     struct MenuSub     *sub;
  643.     struct _MenuItem   *item;
  644.     int                 ret;
  645.  
  646.     if( sub = AllocObject( IE_MENUSUB )) {
  647.  
  648.     buffer4 = sub;
  649.  
  650.     LayoutWindow( MEEditWTags );
  651.     ret = OpenMEEditWindow();
  652.     PostOpenWindow( MEEditWTags );
  653.  
  654.     if( ret ) {
  655.         FreeObject( sub, IE_MENUSUB );
  656.         DisplayBeep( Scr );
  657.     } else {
  658.  
  659.         ME_AttivaChecks();
  660.  
  661.         RetCode = 0;
  662.         do {
  663.         ReqHandle( MEEditWnd, HandleMEEditIDCMP );
  664.         } while(!( RetCode ));
  665.  
  666.         if( sub->msn_Flags & M_BARLABEL )
  667.         sub->msn_Node.ln_Name = Bar_txt;
  668.         else
  669.         strcpy( sub->msn_Text, GetString( MEEditGadgets[ GD_MEd_Txt ]) );
  670.  
  671.         strcpy( sub->msn_Label, GetString( MEEditGadgets[ GD_MEd_Label ]) );
  672.         strcpy( sub->msn_CommKey, GetString( MEEditGadgets[ GD_MEd_CmdK ]) );
  673.  
  674.         if( RetCode < 0 ) {
  675.  
  676.         ME_AttivaSub();
  677.         StaccaSubList();
  678.  
  679.         item = GetItemSel();
  680.         List2Tag3[1] = List2Tag3[3] = item->min_NumSubs;
  681.         item->min_NumSubs += 1;
  682.  
  683.         AddTail(( struct List * )&item->min_Subs, (struct Node *)sub );
  684.  
  685.         AttaccaSubList();
  686.  
  687.         IE.flags &= ~SALVATO;
  688.  
  689.         LastSub = -1;
  690.  
  691.         } else {
  692.         FreeObject( sub, IE_MENUSUB );
  693.         }
  694.     }
  695.  
  696.     CloseMEEditWindow();
  697.  
  698.     } else {
  699.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  700.     }
  701.  
  702.     return( TRUE );
  703. }
  704.  
  705. BOOL ME_INuovoClicked( void )
  706. {
  707.     struct MenuTitle   *menu;
  708.     struct _MenuItem   *item;
  709.     int                 ret;
  710.  
  711.     if( item = AllocObject( IE_MENUITEM )) {
  712.  
  713.     buffer4 = item;
  714.  
  715.     LayoutWindow( MEEditWTags );
  716.     ret = OpenMEEditWindow();
  717.     PostOpenWindow( MEEditWTags );
  718.  
  719.     if( ret ) {
  720.         FreeObject( item, IE_MENUITEM );
  721.         DisplayBeep( Scr );
  722.     } else {
  723.  
  724.         ME_AttivaChecks();
  725.  
  726.         RetCode = 0;
  727.         do {
  728.         ReqHandle( MEEditWnd, HandleMEEditIDCMP );
  729.         } while(!( RetCode ));
  730.  
  731.         if( item->min_Flags & M_BARLABEL )
  732.         item->min_Node.ln_Name = Bar_txt;
  733.         else
  734.         strcpy( item->min_Text, GetString( MEEditGadgets[ GD_MEd_Txt ]) );
  735.         strcpy( item->min_Label, GetString( MEEditGadgets[ GD_MEd_Label ]) );
  736.         strcpy( item->min_CommKey, GetString( MEEditGadgets[ GD_MEd_CmdK ]) );
  737.  
  738.         if( RetCode < 0 ) {
  739.  
  740.         ME_AttivaItem();
  741.         StaccaItemList();
  742.  
  743.         menu = GetMenuSel();
  744.         List2Tag2[1] = List2Tag2[3] = menu->mt_NumItems;
  745.         menu->mt_NumItems += 1;
  746.  
  747.         AddTail(( struct List * )&menu->mt_Items, (struct Node *)item );
  748.  
  749.         AttaccaItemList();
  750.         AggiornaSub();
  751.  
  752.         IE.flags &= ~SALVATO;
  753.  
  754.         LastItem = -1;
  755.  
  756.         } else {
  757.         FreeObject( item, IE_MENUITEM );
  758.         }
  759.     }
  760.  
  761.     CloseMEEditWindow();
  762.  
  763.     } else {
  764.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  765.     }
  766.  
  767.     return( TRUE );
  768. }
  769. ///
  770. /// Routine di gestione del MenuEd
  771. void StaccaMenuList( void )
  772. {
  773.     ListTag[1] = NULL;
  774.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Title ], MenuEdWnd,
  775.             NULL, (struct TagItem *)ListTag );
  776. }
  777.  
  778. void AttaccaMenuList( void )
  779. {
  780.     ListTag[1] = &IE.win_info->wi_Menus;
  781.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Title ], MenuEdWnd,
  782.             NULL, (struct TagItem *)ListTag );
  783.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Title ], MenuEdWnd,
  784.             NULL, (struct TagItem *)List2Tag );
  785. }
  786.  
  787. void StaccaItemList( void )
  788. {
  789.     ListTag[1] = NULL;
  790.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Item ], MenuEdWnd,
  791.             NULL, (struct TagItem *)ListTag );
  792. }
  793.  
  794. void AttaccaItemList( void )
  795. {
  796.     struct MenuTitle *menu;
  797.  
  798.     menu = GetMenuSel();
  799.  
  800.     ListTag[1] = &menu->mt_Items;
  801.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Item ], MenuEdWnd,
  802.             NULL, (struct TagItem *)ListTag );
  803.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Item ], MenuEdWnd,
  804.             NULL, (struct TagItem *)List2Tag2 );
  805. }
  806.  
  807. void StaccaSubList( void )
  808. {
  809.     ListTag[1] = NULL;
  810.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Sub ], MenuEdWnd,
  811.             NULL, (struct TagItem *)ListTag );
  812. }
  813.  
  814. void AttaccaSubList( void )
  815. {
  816.     struct _MenuItem *item;
  817.  
  818.     item = GetItemSel();
  819.  
  820.     ListTag[1] = &item->min_Subs;
  821.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Sub ], MenuEdWnd,
  822.             NULL, (struct TagItem *)ListTag );
  823.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Sub ], MenuEdWnd,
  824.             NULL, (struct TagItem *)List2Tag3 );
  825. }
  826.  
  827. void ME_AttivaTitle( void )
  828. {
  829.     struct Window  *wnd;
  830.  
  831.     if( TitleAct ) {
  832.  
  833.     TitleAct = FALSE;
  834.  
  835.     wnd = MenuEdWnd;
  836.  
  837.     DisableTag[1] = FALSE;
  838.  
  839.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Title ], MenuEdWnd,
  840.                 NULL, (struct TagItem *)DisableTag );
  841.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Item ], MenuEdWnd,
  842.                 NULL, (struct TagItem *)DisableTag );
  843.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_INuovo ], MenuEdWnd,
  844.                 NULL, (struct TagItem *)DisableTag );
  845.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_TDel ], MenuEdWnd,
  846.                 NULL, (struct TagItem *)DisableTag );
  847.     }
  848.  
  849.     OnGadget( &ME_TSuGadget, MenuEdWnd, NULL );
  850.     OnGadget( &ME_TGiuGadget, MenuEdWnd, NULL );
  851. }
  852.  
  853. void ME_AttivaItem( void )
  854. {
  855.     struct Window  *wnd;
  856.  
  857.     if( ItemAct ) {
  858.  
  859.     ItemAct = FALSE;
  860.  
  861.     wnd = MenuEdWnd;
  862.  
  863.     DisableTag[1] = FALSE;
  864.  
  865.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Sub ], MenuEdWnd,
  866.                 NULL, (struct TagItem *)DisableTag );
  867.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_IDel ], MenuEdWnd,
  868.                 NULL, (struct TagItem *)DisableTag );
  869.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SNuovo ], MenuEdWnd,
  870.                 NULL, (struct TagItem *)DisableTag );
  871.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_IExclude ], MenuEdWnd,
  872.                 NULL, (struct TagItem *)DisableTag );
  873.     }
  874.  
  875.     OnGadget( &ME_ISuGadget, MenuEdWnd, NULL );
  876.     OnGadget( &ME_IGiuGadget, MenuEdWnd, NULL );
  877. }
  878.  
  879. void ME_DisattivaItem( void )
  880. {
  881.     struct Window  *wnd;
  882.  
  883.     if(!( ItemAct )) {
  884.  
  885.     ItemAct = TRUE;
  886.  
  887.     wnd = MenuEdWnd;
  888.  
  889.     DisableTag[1] = TRUE;
  890.  
  891.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Sub ], MenuEdWnd,
  892.                 NULL, (struct TagItem *)DisableTag );
  893.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_IDel ], MenuEdWnd,
  894.                 NULL, (struct TagItem *)DisableTag );
  895.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SNuovo ], MenuEdWnd,
  896.                 NULL, (struct TagItem *)DisableTag );
  897.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_IExclude ], MenuEdWnd,
  898.                 NULL, (struct TagItem *)DisableTag );
  899.     }
  900.  
  901.     OffGadget( &ME_ISuGadget, MenuEdWnd, NULL );
  902.     OffGadget( &ME_IGiuGadget, MenuEdWnd, NULL );
  903. }
  904.  
  905. void ME_DisattivaTitle( void )
  906. {
  907.     struct Window  *wnd;
  908.  
  909.     if(!( TitleAct )) {
  910.  
  911.     TitleAct = TRUE;
  912.  
  913.     wnd = MenuEdWnd;
  914.  
  915.     DisableTag[1] = TRUE;
  916.  
  917.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Title ], MenuEdWnd,
  918.                 NULL, (struct TagItem *)DisableTag );
  919.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_Item ], MenuEdWnd,
  920.                 NULL, (struct TagItem *)DisableTag );
  921.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_INuovo ], MenuEdWnd,
  922.                 NULL, (struct TagItem *)DisableTag );
  923.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_TDel ], MenuEdWnd,
  924.                 NULL, (struct TagItem *)DisableTag );
  925.     }
  926.  
  927.     OffGadget( &ME_TSuGadget, MenuEdWnd, NULL );
  928.     OffGadget( &ME_TGiuGadget, MenuEdWnd, NULL );
  929. }
  930.  
  931. void ME_AttivaSub( void )
  932. {
  933.     struct Window  *wnd;
  934.  
  935.     if( SubAct ) {
  936.  
  937.     SubAct = FALSE;
  938.  
  939.     wnd = MenuEdWnd;
  940.  
  941.     DisableTag[1] = FALSE;
  942.  
  943.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SDel ], MenuEdWnd,
  944.                 NULL, (struct TagItem *)DisableTag );
  945.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SExclude ], MenuEdWnd,
  946.                 NULL, (struct TagItem *)DisableTag );
  947.     }
  948.  
  949.     OnGadget( &ME_SSuGadget, MenuEdWnd, NULL );
  950.     OnGadget( &ME_SGiuGadget, MenuEdWnd, NULL );
  951. }
  952.  
  953. void ME_DisattivaSub( void )
  954. {
  955.     struct Window  *wnd;
  956.  
  957.     if(!( SubAct )) {
  958.  
  959.     SubAct = TRUE;
  960.  
  961.     wnd = MenuEdWnd;
  962.  
  963.     DisableTag[1] = TRUE;
  964.  
  965.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SDel ], MenuEdWnd,
  966.                 NULL, (struct TagItem *)DisableTag );
  967.     GT_SetGadgetAttrsA( MenuEdGadgets[ GD_ME_SExclude ], MenuEdWnd,
  968.                 NULL, (struct TagItem *)DisableTag );
  969.     }
  970.  
  971.     OffGadget( &ME_SSuGadget, MenuEdWnd, NULL );
  972.     OffGadget( &ME_SGiuGadget, MenuEdWnd, NULL );
  973. }
  974.  
  975. void ME_AttivaChecks( void )
  976. {
  977.     DisableTag[1] = FALSE;
  978.  
  979.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Bar ], MEEditWnd,
  980.             NULL, (struct TagItem *)DisableTag );
  981.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Toggle ], MEEditWnd,
  982.             NULL, (struct TagItem *)DisableTag );
  983.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ChkIt ], MEEditWnd,
  984.             NULL, (struct TagItem *)DisableTag );
  985.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Checked ], MEEditWnd,
  986.             NULL, (struct TagItem *)DisableTag );
  987.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Img ], MEEditWnd,
  988.             NULL, (struct TagItem *)DisableTag );
  989.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Label ], MEEditWnd,
  990.             NULL, (struct TagItem *)DisableTag );
  991.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_CmdK ], MEEditWnd,
  992.             NULL, (struct TagItem *)DisableTag );
  993. }
  994.  
  995. void AggiornaItemSub( void )
  996. {
  997.     struct MenuTitle   *menu;
  998.     struct _MenuItem   *item;
  999.  
  1000.     StaccaItemList();
  1001.     StaccaSubList();
  1002.  
  1003.     if( menu = GetMenuSel() ) {
  1004.  
  1005.     if( menu->mt_NumItems ) {
  1006.         ME_AttivaItem();
  1007.         AttaccaItemList();
  1008.  
  1009.         item = menu->mt_Items.mlh_Head;
  1010.  
  1011.         if( item->min_NumSubs ) {
  1012.         ME_AttivaSub();
  1013.         List2Tag3[1] = List2Tag3[3] = 0;
  1014.         AttaccaSubList();
  1015.         } else
  1016.         ME_DisattivaSub();
  1017.  
  1018.     } else
  1019.         ME_DisattivaItem();
  1020.     }
  1021. }
  1022.  
  1023. void AggiornaSub( void )
  1024. {
  1025.     struct _MenuItem   *item;
  1026.  
  1027.     StaccaSubList();
  1028.  
  1029.     if( item = GetItemSel() ) {
  1030.     if( item->min_NumSubs ) {
  1031.         ME_AttivaSub();
  1032.         List2Tag3[1] = List2Tag3[3] = 0;
  1033.         AttaccaSubList();
  1034.     } else {
  1035.         ME_DisattivaSub();
  1036.     }
  1037.     } else {
  1038.     ME_DisattivaSub();
  1039.     }
  1040. }
  1041.  
  1042. struct MenuTitle *GetMenuSel( void )
  1043. {
  1044.     struct MenuTitle *menu;
  1045.     int               cnt;
  1046.  
  1047.     menu = (struct MenuTitle *)&IE.win_info->wi_Menus;
  1048.     for( cnt = 0; cnt <= List2Tag[1]; cnt++ ) {
  1049.     menu = menu->mt_Node.ln_Succ;
  1050.     if(!( menu->mt_Node.ln_Succ ))
  1051.         return( NULL );
  1052.     }
  1053.  
  1054.     return( menu );
  1055. }
  1056.  
  1057. struct _MenuItem *GetItemSel( void )
  1058. {
  1059.     struct MenuTitle *menu;
  1060.     struct _MenuItem *item = NULL;
  1061.     int               cnt;
  1062.  
  1063.     if( menu = GetMenuSel() ) {
  1064.  
  1065.     if( menu->mt_NumItems ) {
  1066.  
  1067.         item = (struct _MenuItem *)&menu->mt_Items;
  1068.  
  1069.         for( cnt = 0; cnt <= List2Tag2[1]; cnt++ ) {
  1070.         item = item->min_Node.ln_Succ;
  1071.         if(!( item->min_Node.ln_Succ ))
  1072.             return( NULL );
  1073.         }
  1074.     }
  1075.     }
  1076.  
  1077.     return( item );
  1078. }
  1079.  
  1080. struct MenuSub *GetSubSel( void )
  1081. {
  1082.     struct _MenuItem *item;
  1083.     struct MenuSub   *sub = NULL;
  1084.     int               cnt;
  1085.  
  1086.     if( item = GetItemSel() ) {
  1087.  
  1088.     if( item->min_NumSubs ) {
  1089.  
  1090.         sub = (struct MenuSub *)&item->min_Subs;
  1091.  
  1092.         for( cnt = 0; cnt <= List2Tag3[1]; cnt++ ) {
  1093.         sub = sub->msn_Node.ln_Succ;
  1094.         if(!( sub->msn_Node.ln_Succ ))
  1095.             return( NULL );
  1096.         }
  1097.     }
  1098.     }
  1099.  
  1100.     return( sub );
  1101. }
  1102. ///
  1103. /// Test Menu
  1104. BOOL ME_TestClicked( void )
  1105. {
  1106.     struct MenuTitle   *menu;
  1107.     struct _MenuItem   *item;
  1108.     struct MenuSub     *sub;
  1109.     struct NewMenu     *newmenu;
  1110.     ULONG               total, class;
  1111.     UWORD               num, flags;
  1112.     struct Menu        *menus;
  1113.     struct IntuiMessage *msg;
  1114.     struct Gadget      *gad;
  1115.  
  1116.     total = IE.win_info->wi_NumMenus + 1;
  1117.  
  1118.     for( menu = IE.win_info->wi_Menus.mlh_Head; menu->mt_Node.ln_Succ; menu = menu->mt_Node.ln_Succ ) {
  1119.  
  1120.     total += menu->mt_NumItems;
  1121.  
  1122.     for( item = menu->mt_Items.mlh_Head; item->min_Node.ln_Succ; item = item->min_Node.ln_Succ )
  1123.         total += item->min_NumSubs;
  1124.     }
  1125.  
  1126.     total *= sizeof( struct NewMenu );
  1127.  
  1128.     if( newmenu = AllocMem( total, MEMF_CLEAR )) {
  1129.  
  1130.     num = 0;
  1131.  
  1132.     for( menu = IE.win_info->wi_Menus.mlh_Head; menu->mt_Node.ln_Succ; menu = menu->mt_Node.ln_Succ ) {
  1133.  
  1134.         newmenu[ num ].nm_Type  = NM_TITLE;
  1135.         newmenu[ num ].nm_Label = menu->mt_Node.ln_Name;
  1136.         newmenu[ num ].nm_Flags = ( menu->mt_Flags & M_DISABLED ) ? NM_MENUDISABLED : 0;
  1137.  
  1138.         for( item = menu->mt_Items.mlh_Head; item->min_Node.ln_Succ; item = item->min_Node.ln_Succ ) {
  1139.  
  1140.         num++;
  1141.  
  1142.         newmenu[ num ].nm_Type = item->min_Image ? IM_ITEM : NM_ITEM;
  1143.  
  1144.         if(!( item->min_Image ))
  1145.             newmenu[ num ].nm_Label = ( item->min_Flags & M_BARLABEL ) ? (APTR)NM_BARLABEL : item->min_Node.ln_Name;
  1146.         else
  1147.             newmenu[ num ].nm_Label = item->min_Image;
  1148.  
  1149.         if(!( item->min_NumSubs ))
  1150.             if( item->min_CommKey[0] )
  1151.             newmenu[ num ].nm_CommKey = item->min_CommKey;
  1152.  
  1153.         flags = 0;
  1154.  
  1155.         if( item->min_Flags & M_DISABLED )
  1156.             flags = NM_ITEMDISABLED;
  1157.  
  1158.         if( item->min_Flags & M_CHECKIT )
  1159.             flags |= CHECKIT;
  1160.  
  1161.         if( item->min_Flags & M_CHECKED )
  1162.             flags |= CHECKED;
  1163.  
  1164.         if( item->min_Flags & M_MENUTOGGLE )
  1165.             flags |= MENUTOGGLE;
  1166.  
  1167.         if( item->min_CommKey[0] )
  1168.             if( item->min_CommKey[1] )
  1169.             flags |= NM_COMMANDSTRING;
  1170.  
  1171.         newmenu[ num ].nm_Flags = flags;
  1172.         newmenu[ num ].nm_MutualExclude = item->min_MutualExclude;
  1173.  
  1174.         for( sub = item->min_Subs.mlh_Head; sub->msn_Node.ln_Succ; sub = sub->msn_Node.ln_Succ ) {
  1175.  
  1176.             num++;
  1177.  
  1178.             newmenu[ num ].nm_Type = sub->msn_Image ? IM_SUB : NM_SUB;
  1179.  
  1180.             if(!( sub->msn_Image ))
  1181.             newmenu[ num ].nm_Label = ( sub->msn_Flags & M_BARLABEL ) ? (APTR)NM_BARLABEL : sub->msn_Node.ln_Name;
  1182.             else
  1183.             newmenu[ num ].nm_Label = sub->msn_Image;
  1184.  
  1185.             if( sub->msn_CommKey[0] )
  1186.             newmenu[ num ].nm_CommKey = sub->msn_CommKey;
  1187.  
  1188.             flags = 0;
  1189.  
  1190.             if( sub->msn_Flags & M_DISABLED )
  1191.             flags = NM_ITEMDISABLED;
  1192.  
  1193.             if( sub->msn_Flags & M_CHECKIT )
  1194.             flags |= CHECKIT;
  1195.  
  1196.             if( sub->msn_Flags & M_CHECKED )
  1197.             flags |= CHECKED;
  1198.  
  1199.             if( sub->msn_Flags & M_MENUTOGGLE )
  1200.             flags |= MENUTOGGLE;
  1201.  
  1202.             if( sub->msn_CommKey[0] )
  1203.             if( sub->msn_CommKey[1] )
  1204.                 flags |= NM_COMMANDSTRING;
  1205.  
  1206.             newmenu[ num ].nm_Flags = flags;
  1207.             newmenu[ num ].nm_MutualExclude = sub->msn_MutualExclude;
  1208.         }
  1209.         }
  1210.  
  1211.         num++;
  1212.     }
  1213.  
  1214.     if( menus = CreateMenusA( newmenu, NULL )) {
  1215.  
  1216.         LayoutMenus( menus, VisualInfo, GTMN_NewLookMenus, TRUE, TAG_END );
  1217.  
  1218.         SetMenuStrip( MenuEdWnd, menus );
  1219.  
  1220.         flags = TRUE;
  1221.  
  1222.         do {
  1223.         WaitPort( MenuEdWnd->UserPort );
  1224.  
  1225.         while( msg = GT_GetIMsg( MenuEdWnd->UserPort )) {
  1226.  
  1227.             class = msg->Class;
  1228.             gad   = msg->IAddress;
  1229.  
  1230.             GT_ReplyIMsg( msg );
  1231.  
  1232.             switch( class ) {
  1233.             case IDCMP_REFRESHWINDOW:
  1234.                 GT_BeginRefresh( MenuEdWnd );
  1235.                 GT_EndRefresh( MenuEdWnd, TRUE );
  1236.                 break;
  1237.  
  1238.             case IDCMP_GADGETUP:
  1239.                 if( gad->GadgetID == GD_ME_Test )
  1240.                 flags = FALSE;
  1241.                 break;
  1242.             }
  1243.         }
  1244.         } while( flags );
  1245.  
  1246.         ClearMenuStrip( MenuEdWnd );
  1247.         FreeMenus( menus );
  1248.  
  1249.     } else
  1250.         DisplayBeep( Scr );
  1251.  
  1252.     FreeMem( newmenu, total );
  1253.  
  1254.     } else
  1255.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1256.  
  1257.     return( TRUE );
  1258. }
  1259. ///
  1260. /// Edita un item/sub
  1261. BOOL MEd_ImgKeyPressed( void )
  1262. {
  1263.     MEd_ImgClicked();
  1264. }
  1265.  
  1266. BOOL MEd_ImgClicked( void )
  1267. {
  1268.     UWORD               cnt;
  1269.     WORD                num;
  1270.     struct ImageNode   *img;
  1271.  
  1272.     if( ApriListaFin( CatCompArray[ REQ_GETIMG ].cca_Str, REQ_GETIMG, &IE.Img_List )) {
  1273.  
  1274.     num = GestisciListaFin( EXIT, IE.NumImgs );
  1275.     ChiudiListaFin();
  1276.  
  1277.     if( num >= 0 ) {
  1278.         if(!( num )) {
  1279.         ((struct _MenuItem *)buffer4)->min_Image = NULL;
  1280.         TextTag[1] = "---";
  1281.         } else {
  1282.  
  1283.         img = (struct ImageNode *)&IE.Img_List;
  1284.         for( cnt = 0; cnt <= num; cnt++ )
  1285.             img = img->in_Node.ln_Succ;
  1286.  
  1287.         ((struct _MenuItem *)buffer4)->min_Image = &img->in_Left;
  1288.         TextTag[1] = img->in_Node.ln_Name;
  1289.         }
  1290.  
  1291.         GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ImgDisp ], MEEditWnd,
  1292.                 NULL, (struct TagItem *)TextTag );
  1293.  
  1294.         IE.flags &= ~SALVATO;
  1295.     }
  1296.     }
  1297. }
  1298.  
  1299. void ME_EditTitle( struct MenuTitle *menu )
  1300. {
  1301.     int     ret;
  1302.     UBYTE   BackUpFlags;
  1303.  
  1304.     LayoutWindow( MEEditWTags );
  1305.     ret = OpenMEEditWindow();
  1306.     PostOpenWindow( MEEditWTags );
  1307.  
  1308.     if( ret ) {
  1309.     DisplayBeep( Scr );
  1310.     } else {
  1311.  
  1312.     BackUpFlags = menu->mt_Flags;
  1313.  
  1314.     MEd_SetChecks(( struct _MenuItem *)menu );
  1315.  
  1316.     StringTag[1] = menu->mt_Node.ln_Name;
  1317.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Txt ], MEEditWnd,
  1318.                 NULL, (struct TagItem *)StringTag );
  1319.  
  1320.     StringTag[1] = menu->mt_Label;
  1321.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Label ], MEEditWnd,
  1322.                 NULL, (struct TagItem *)StringTag );
  1323.  
  1324.     ActivateGadget( MEEditGadgets[ GD_MEd_Txt ], MEEditWnd, NULL );
  1325.  
  1326.     buffer4 = menu;
  1327.  
  1328.     RetCode = 0;
  1329.  
  1330.     do {
  1331.         ReqHandle( MEEditWnd, HandleMEEditIDCMP );
  1332.     } while(!( RetCode ));
  1333.  
  1334.     if( RetCode < 0 ) {
  1335.  
  1336.         StaccaMenuList();
  1337.         strcpy( menu->mt_Text, GetString( MEEditGadgets[ GD_MEd_Txt ]) );
  1338.         strcpy( menu->mt_Label, GetString( MEEditGadgets[ GD_MEd_Label ]) );
  1339.         AttaccaMenuList();
  1340.  
  1341.         IE.flags &= ~SALVATO;
  1342.  
  1343.     } else {
  1344.         menu->mt_Flags = BackUpFlags;
  1345.     }
  1346.     }
  1347.  
  1348.     CloseMEEditWindow();
  1349. }
  1350.  
  1351. void ME_EditItem( struct _MenuItem *item )
  1352. {
  1353.     int                 ret;
  1354.     UBYTE               BackUpFlags;
  1355.     APTR                BackUpImage;
  1356.     struct ImageNode   *in;
  1357.  
  1358.     LayoutWindow( MEEditWTags );
  1359.     ret = OpenMEEditWindow();
  1360.     PostOpenWindow( MEEditWTags );
  1361.  
  1362.     if( ret ) {
  1363.     DisplayBeep( Scr );
  1364.     } else {
  1365.  
  1366.     BackUpFlags = item->min_Flags;
  1367.     BackUpImage = item->min_Image;
  1368.  
  1369.     buffer4 = item;
  1370.  
  1371.     MEd_SetChecks( item );
  1372.     ME_AttivaChecks();
  1373.  
  1374.     if( in = item->min_Image ) {
  1375.         (ULONG)in -= 14;
  1376.         TextTag[1] = in->in_Node.ln_Name;
  1377.         GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ImgDisp ], MEEditWnd,
  1378.                 NULL, (struct TagItem *)TextTag );
  1379.     }
  1380.  
  1381.     StringTag[1] = item->min_Node.ln_Name;
  1382.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Txt ], MEEditWnd,
  1383.                 NULL, (struct TagItem *)StringTag );
  1384.  
  1385.     StringTag[1] = item->min_Label;
  1386.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Label ], MEEditWnd,
  1387.                 NULL, (struct TagItem *)StringTag );
  1388.  
  1389.     StringTag[1] = item->min_CommKey;
  1390.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_CmdK ], MEEditWnd,
  1391.                 NULL, (struct TagItem *)StringTag );
  1392.  
  1393.     DisableTag[1] = ( item->min_Flags & M_BARLABEL ) ? TRUE : FALSE;
  1394.     MEd_BarLabel();
  1395.  
  1396.     ActivateGadget( MEEditGadgets[ GD_MEd_Txt ], MEEditWnd, NULL );
  1397.  
  1398.     RetCode = 0;
  1399.  
  1400.     do {
  1401.         ReqHandle( MEEditWnd, HandleMEEditIDCMP );
  1402.     } while(!( RetCode ));
  1403.  
  1404.     if( RetCode < 0 ) {
  1405.  
  1406.         StaccaMenuList();
  1407.  
  1408.         if( item->min_Flags & M_BARLABEL ) {
  1409.         item->min_Node.ln_Name = Bar_txt;
  1410.         } else {
  1411.         item->min_Node.ln_Name = item->min_Text;
  1412.         }
  1413.  
  1414.         strcpy( item->min_Text, GetString( MEEditGadgets[ GD_MEd_Txt ]) );
  1415.         strcpy( item->min_Label, GetString( MEEditGadgets[ GD_MEd_Label ]) );
  1416.         strcpy( item->min_CommKey, GetString( MEEditGadgets[ GD_MEd_CmdK ]) );
  1417.         AttaccaMenuList();
  1418.  
  1419.         IE.flags &= ~SALVATO;
  1420.  
  1421.     } else {
  1422.         item->min_Flags = BackUpFlags;
  1423.         item->min_Image = BackUpImage;
  1424.     }
  1425.     }
  1426.  
  1427.     CloseMEEditWindow();
  1428. }
  1429.  
  1430. void MEd_BarLabel( void )
  1431. {
  1432.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Txt ], MEEditWnd,
  1433.             NULL, (struct TagItem *)DisableTag );
  1434.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Label ], MEEditWnd,
  1435.             NULL, (struct TagItem *)DisableTag );
  1436.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Img ], MEEditWnd,
  1437.             NULL, (struct TagItem *)DisableTag );
  1438.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_CmdK ], MEEditWnd,
  1439.             NULL, (struct TagItem *)DisableTag );
  1440.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ChkIt ], MEEditWnd,
  1441.             NULL, (struct TagItem *)DisableTag );
  1442.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Checked ], MEEditWnd,
  1443.             NULL, (struct TagItem *)DisableTag );
  1444.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Toggle ], MEEditWnd,
  1445.             NULL, (struct TagItem *)DisableTag );
  1446. }
  1447.  
  1448. void MEd_SetChecks( struct _MenuItem *item )
  1449. {
  1450.     CheckedTag[1] = ( item->min_Flags & M_BARLABEL ) ? TRUE : FALSE;
  1451.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Bar ], MEEditWnd,
  1452.             NULL, (struct TagItem *)CheckedTag );
  1453.  
  1454.     CheckedTag[1] = ( item->min_Flags & M_DISABLED ) ? TRUE : FALSE;
  1455.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Disab ], MEEditWnd,
  1456.             NULL, (struct TagItem *)CheckedTag );
  1457.  
  1458.     CheckedTag[1] = ( item->min_Flags & M_CHECKIT ) ? TRUE : FALSE;
  1459.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ChkIt ], MEEditWnd,
  1460.             NULL, (struct TagItem *)CheckedTag );
  1461.  
  1462.     CheckedTag[1] = ( item->min_Flags & M_CHECKED ) ? TRUE : FALSE;
  1463.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Checked ], MEEditWnd,
  1464.             NULL, (struct TagItem *)CheckedTag );
  1465.  
  1466.     CheckedTag[1] = ( item->min_Flags & M_MENUTOGGLE ) ? TRUE : FALSE;
  1467.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Toggle ], MEEditWnd,
  1468.             NULL, (struct TagItem *)CheckedTag );
  1469. }
  1470.  
  1471. BOOL MEd_BarKeyPressed( void )
  1472. {
  1473.     CheckedTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_BARLABEL ) ? FALSE : TRUE;
  1474.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Bar ], MEEditWnd,
  1475.             NULL, (struct TagItem *)CheckedTag );
  1476.  
  1477.     MEd_BarClicked();
  1478. }
  1479.  
  1480. BOOL MEd_BarClicked( void )
  1481. {
  1482.     ((struct _MenuItem *)buffer4)->min_Flags ^= M_BARLABEL;
  1483.  
  1484.     DisableTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_BARLABEL ) ? TRUE : FALSE;
  1485.     MEd_BarLabel();
  1486. }
  1487.  
  1488. BOOL MEd_DisabKeyPressed( void )
  1489. {
  1490.     CheckedTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_DISABLED ) ? FALSE : TRUE;
  1491.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Disab ], MEEditWnd,
  1492.             NULL, (struct TagItem *)CheckedTag );
  1493.  
  1494.     MEd_DisabClicked();
  1495. }
  1496.  
  1497. BOOL MEd_DisabClicked( void )
  1498. {
  1499.     ((struct _MenuItem *)buffer4)->min_Flags ^= M_DISABLED;
  1500. }
  1501.  
  1502. BOOL MEd_ChkItKeyPressed( void )
  1503. {
  1504.     CheckedTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_CHECKIT ) ? FALSE : TRUE;
  1505.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_ChkIt ], MEEditWnd,
  1506.             NULL, (struct TagItem *)CheckedTag );
  1507.  
  1508.     MEd_ChkItClicked();
  1509. }
  1510.  
  1511. BOOL MEd_ChkItClicked( void )
  1512. {
  1513.     ((struct _MenuItem *)buffer4)->min_Flags ^= M_CHECKIT;
  1514. }
  1515.  
  1516. BOOL MEd_CheckedKeyPressed( void )
  1517. {
  1518.     CheckedTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_CHECKED ) ? FALSE : TRUE;
  1519.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Checked ], MEEditWnd,
  1520.             NULL, (struct TagItem *)CheckedTag );
  1521.  
  1522.     MEd_CheckedClicked();
  1523. }
  1524.  
  1525. BOOL MEd_CheckedClicked( void )
  1526. {
  1527.     ((struct _MenuItem *)buffer4)->min_Flags ^= M_CHECKED;
  1528. }
  1529.  
  1530. BOOL MEd_ToggleKeyPressed( void )
  1531. {
  1532.     CheckedTag[1] = ( ((struct _MenuItem *)buffer4)->min_Flags & M_MENUTOGGLE ) ? FALSE : TRUE;
  1533.     GT_SetGadgetAttrsA( MEEditGadgets[ GD_MEd_Toggle ], MEEditWnd,
  1534.             NULL, (struct TagItem *)CheckedTag );
  1535.  
  1536.     MEd_ToggleClicked();
  1537. }
  1538.  
  1539. BOOL MEd_ToggleClicked( void )
  1540. {
  1541.     ((struct _MenuItem *)buffer4)->min_Flags ^= M_MENUTOGGLE;
  1542. }
  1543.  
  1544. BOOL MEd_TxtClicked( void )
  1545. {
  1546.     if(!( MEEditGadgets[ GD_MEd_CmdK ]->Flags & GFLG_DISABLED ))
  1547.     ActivateGadget( MEEditGadgets[ GD_MEd_CmdK ], MEEditWnd, NULL );
  1548. }
  1549.  
  1550. BOOL MEd_CmdKClicked( void )
  1551. {
  1552.     ActivateGadget( MEEditGadgets[ GD_MEd_Label ], MEEditWnd, NULL );
  1553. }
  1554.  
  1555. BOOL MEd_LabelClicked( void )
  1556. {
  1557. }
  1558.  
  1559. BOOL MEd_OkClicked( void )
  1560. {
  1561.     RetCode = -1;
  1562. }
  1563.  
  1564. BOOL MEd_AnnullaClicked( void )
  1565. {
  1566.     RetCode = 1;
  1567. }
  1568.  
  1569. BOOL MEd_OkKeyPressed( void )
  1570. {
  1571.     RetCode = -1;
  1572. }
  1573.  
  1574. BOOL MEd_AnnullaKeyPressed( void )
  1575. {
  1576.     RetCode = 1;
  1577. }
  1578.  
  1579. BOOL MEEditVanillaKey( void )
  1580. {
  1581.     switch( MEEditMsg.Code ) {
  1582.     case 13:
  1583.         RetCode = -1;
  1584.         break;
  1585.     case 27:
  1586.         RetCode = 1;
  1587.         break;
  1588.     }
  1589. }
  1590. ///
  1591. /// Edita i Mutual Exclude
  1592. void OpenMutualExclude( struct MinList *list, struct _MenuItem *item )
  1593. {
  1594.     int                 ret, cnt, num = -1;
  1595.     struct _MenuItem   *mi;
  1596.     struct _MenuItem  **back;
  1597.     ULONG               size = 0, mx = 0;
  1598.  
  1599.     NewList((struct List *)&Inc_List );
  1600.     NewList((struct List *)&Exc_List );
  1601.     NewList((struct List *)&Other_List );
  1602.  
  1603.     for( mi = list->mlh_Head; mi->min_Node.ln_Succ; mi = mi->min_Node.ln_Succ )
  1604.     size += sizeof( struct _MenuItem * );
  1605.  
  1606.     if(!( back = AllocMem( size, MEMF_ANY ))) {
  1607.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1608.     return;
  1609.     }
  1610.  
  1611.     while( mi = RemHead((struct List *)list )) {
  1612.  
  1613.     num += 1;
  1614.  
  1615.     back[ num ] = mi;
  1616.  
  1617.     if(( mi->min_Flags & M_BARLABEL ) || ( mi == item )) {
  1618.         AddTail((struct List *)&Other_List, (struct Node *)mi );
  1619.     } else {
  1620.         if( item->min_MutualExclude & ( 1 << num )) {
  1621.         AddTail((struct List *)&Exc_List, (struct Node *)mi );
  1622.         } else {
  1623.         AddTail((struct List *)&Inc_List, (struct Node *)mi );
  1624.         }
  1625.     }
  1626.     }
  1627.  
  1628.     VarA = VarB = -1;
  1629.  
  1630.     LayoutWindow( MutualXWTags );
  1631.     ret = OpenMutualXWindow();
  1632.     PostOpenWindow( MutualXWTags );
  1633.  
  1634.     if( ret ) {
  1635.     DisplayBeep( Scr );
  1636.     } else {
  1637.  
  1638.     MX_AttaccaIncList();
  1639.     MX_AttaccaExcList();
  1640.  
  1641.     RetCode = 0;
  1642.  
  1643.     do {
  1644.         ReqHandle( MutualXWnd, HandleMutualXIDCMP );
  1645.     } while(!( RetCode ));
  1646.  
  1647.     if( RetCode < 0 ) {
  1648.  
  1649.         for( mi = Exc_List.mlh_Head; mi->min_Node.ln_Succ; mi = mi->min_Node.ln_Succ ) {
  1650.  
  1651.         cnt = 0;
  1652.         while( back[ cnt ] != mi )
  1653.             cnt++;
  1654.  
  1655.         mx |= 1 << cnt;
  1656.         }
  1657.  
  1658.         item->min_MutualExclude = mx;
  1659.     }
  1660.     }
  1661.  
  1662.     for( cnt = 0; cnt <= num; cnt++ )
  1663.     AddTail((struct List *)list, (struct Node *)back[ cnt ]);
  1664.  
  1665.     CloseMutualXWindow();
  1666.  
  1667.     FreeMem( back, size );
  1668. }
  1669.  
  1670. void MX_StaccaExcList( void )
  1671. {
  1672.     ListTag[1] = NULL;
  1673.     GT_SetGadgetAttrsA( MutualXGadgets[ GD_MX_Exc ], MutualXWnd,
  1674.             NULL, (struct TagItem *)ListTag );
  1675. }
  1676.  
  1677. void MX_AttaccaExcList( void )
  1678. {
  1679.     ListTag[1] = &Exc_List;
  1680.     GT_SetGadgetAttrsA( MutualXGadgets[ GD_MX_Exc ], MutualXWnd,
  1681.             NULL, (struct TagItem *)ListTag );
  1682. }
  1683.  
  1684. void MX_StaccaIncList( void )
  1685. {
  1686.     ListTag[1] = NULL;
  1687.     GT_SetGadgetAttrsA( MutualXGadgets[ GD_MX_Inc ], MutualXWnd,
  1688.             NULL, (struct TagItem *)ListTag );
  1689. }
  1690.  
  1691. void MX_AttaccaIncList( void )
  1692. {
  1693.     ListTag[1] = &Inc_List;
  1694.     GT_SetGadgetAttrsA( MutualXGadgets[ GD_MX_Inc ], MutualXWnd,
  1695.             NULL, (struct TagItem *)ListTag );
  1696. }
  1697.  
  1698. // Esclude tutti i nodi
  1699. BOOL MX_ExAllClicked( void )
  1700. {
  1701.     struct Node *node;
  1702.  
  1703.     MX_StaccaIncList();
  1704.     MX_StaccaExcList();
  1705.  
  1706.     while( node = RemHead((struct List *)&Inc_List ))
  1707.     AddTail((struct List *)&Exc_List, node );
  1708.  
  1709.     MX_AttaccaIncList();
  1710.     MX_AttaccaExcList();
  1711.  
  1712.     VarA = VarB = -1;
  1713.  
  1714.     IE.flags &= ~SALVATO;
  1715. }
  1716.  
  1717. BOOL MX_IncAllClicked( void )
  1718. {
  1719.     struct Node *node;
  1720.  
  1721.     MX_StaccaIncList();
  1722.     MX_StaccaExcList();
  1723.  
  1724.     while( node = RemHead((struct List *)&Exc_List ))
  1725.     AddTail((struct List *)&Inc_List, node );
  1726.  
  1727.     MX_AttaccaIncList();
  1728.     MX_AttaccaExcList();
  1729.  
  1730.     VarA = VarB = -1;
  1731.  
  1732.     IE.flags &= ~SALVATO;
  1733. }
  1734.  
  1735. BOOL MX_IncClicked( void )
  1736. {
  1737.     VarA = MutualXMsg.Code;
  1738. }
  1739.  
  1740. BOOL MX_ExcClicked( void )
  1741. {
  1742.     VarB = MutualXMsg.Code;
  1743. }
  1744.  
  1745. BOOL MX_ExThisClicked( void )
  1746. {
  1747.     struct Node    *node;
  1748.     int             cnt;
  1749.  
  1750.     if( VarA >= 0 ) {
  1751.  
  1752.     node = Inc_List.mlh_Head;
  1753.     for( cnt = 0; cnt < VarA; cnt++ )
  1754.         node = node->ln_Succ;
  1755.  
  1756.     MX_StaccaIncList();
  1757.     MX_StaccaExcList();
  1758.  
  1759.     Remove( node );
  1760.     AddTail((struct List *)&Exc_List, node );
  1761.  
  1762.     MX_AttaccaIncList();
  1763.     MX_AttaccaExcList();
  1764.     }
  1765.  
  1766.     VarA = VarB = -1;
  1767.     IE.flags &= ~SALVATO;
  1768. }
  1769.  
  1770. BOOL MX_IncThisClicked( void )
  1771. {
  1772.     struct Node    *node;
  1773.     int             cnt;
  1774.  
  1775.     if( VarB >= 0 ) {
  1776.  
  1777.     node = Exc_List.mlh_Head;
  1778.     for( cnt = 0; cnt < VarB; cnt++ )
  1779.         node = node->ln_Succ;
  1780.  
  1781.     MX_StaccaIncList();
  1782.     MX_StaccaExcList();
  1783.  
  1784.     Remove( node );
  1785.     AddTail((struct List *)&Inc_List, node );
  1786.  
  1787.     MX_AttaccaIncList();
  1788.     MX_AttaccaExcList();
  1789.     }
  1790.  
  1791.     VarA = VarB = -1;
  1792.     IE.flags &= ~SALVATO;
  1793. }
  1794.  
  1795. BOOL MX_OkClicked( void )
  1796. {
  1797.     RetCode = -1;
  1798. }
  1799.  
  1800. BOOL MX_AnnullaClicked( void )
  1801. {
  1802.     RetCode = 1;
  1803. }
  1804. ///
  1805.  
  1806. //      Banco Immagini
  1807. /// Banco Immagini
  1808. BOOL OpenImgBankClicked( void )
  1809. {
  1810.     return( ImgBankMenued() );
  1811. }
  1812.  
  1813. static ULONG    IB_ListTag[] = { GTLV_Top, 0, GTLV_Selected, 0, TAG_END };
  1814.  
  1815. BOOL ImgBankMenued( void )
  1816. {
  1817.     int                 ret;
  1818.     UWORD               y = Scr->WBorTop + Scr->Font->ta_YSize + 1;
  1819.     UWORD               y2 = Scr->WBorBottom + 1;
  1820.     struct ImageNode   *img;
  1821.  
  1822.     if( ImgBankWnd )    /*  Already open?   */
  1823.     return( TRUE );
  1824.  
  1825.     if((( struct Library * )SysBase )->lib_Version >= 39 )
  1826.     IB_ListTag[1] = GTLV_MakeVisible;
  1827.  
  1828.     LayoutWindow( ImgBankWTags );
  1829.     ret = OpenImgBankWindow();
  1830.     PostOpenWindow( ImgBankWTags );
  1831.  
  1832.     if( ret ) {
  1833.     DisplayBeep( Scr );
  1834.     CloseImgBankWindow();
  1835.     } else {
  1836.  
  1837.     SetAPen( ImgBankWnd->RPort, 2 );
  1838.     Move( ImgBankWnd->RPort, 232, y );
  1839.     Draw( ImgBankWnd->RPort, 232, ImgBankWnd->Height - y2 );
  1840.  
  1841.     SetAPen( ImgBankWnd->RPort, 1 );
  1842.     Move( ImgBankWnd->RPort, 233, y );
  1843.     Draw( ImgBankWnd->RPort, 233, ImgBankWnd->Height - y2 );
  1844.  
  1845.     buffer2 = FALSE;
  1846.  
  1847.     if( IE.NumImgs ) {
  1848.  
  1849.         buffer2 = TRUE;
  1850.  
  1851.         IB_ListTag[1] = IB_ListTag[3] = 0;
  1852.         AttaccaImgList();
  1853.  
  1854.         img = IE.Img_List.mlh_Head;
  1855.  
  1856.         DrawImg( ImgBankWnd, img, 235, 1 );
  1857.  
  1858.         DisableTag[1] = FALSE;
  1859.         GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  1860.                 NULL, (struct TagItem *)DisableTag );
  1861.         GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Del ], ImgBankWnd,
  1862.                 NULL, (struct TagItem *)DisableTag );
  1863.  
  1864.         StringTag[1] = img->in_Node.ln_Name;
  1865.         GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  1866.                 NULL, (struct TagItem *)StringTag );
  1867.     }
  1868.  
  1869.     ImgBankWnd->ExtData = HandleImgBank;
  1870.     }
  1871.  
  1872.     return( TRUE );
  1873. }
  1874.  
  1875. void HandleImgBank( void )
  1876. {
  1877.     if(!( HandleImgBankIDCMP() ))
  1878.     CloseImgBankWindow();
  1879. }
  1880.  
  1881. BOOL ImgBankCloseWindow( void )
  1882. {
  1883.     return( FALSE );
  1884. }
  1885.  
  1886. BOOL IB_NewKeyPressed( void )
  1887. {
  1888.     return( IB_NewClicked() );
  1889. }
  1890.  
  1891. BOOL IB_NewClicked( void )
  1892. {
  1893.     struct ImageNode       *img;
  1894.     UWORD                   ret;
  1895.     struct BitMapHeader    *bmh;
  1896.     struct ContextNode     *cn;
  1897.     BYTE                   *buf, *dest, *buf2;
  1898.  
  1899.     if( img = AllocObject( IE_IMAGE )) {
  1900.     BOOL ok = FALSE;
  1901.  
  1902.     if( GetImgFile( FALSE, CatCompArray[ ASL_LOADIMG ].cca_Str, ASL_LOADIMG, NULL )) {
  1903.         struct IFFHandle       *iff;
  1904.  
  1905.         if( iff = AllocIFF() ) {
  1906.         if( iff->iff_Stream = Open( allpath, MODE_OLDFILE )) {
  1907.  
  1908.             InitIFFasDOS( iff );
  1909.  
  1910.             if(!( OpenIFF( iff, IFFF_READ ))) {
  1911.  
  1912.             PropChunk( iff, 'ILBM', 'BMHD' );
  1913.             StopChunk( iff, 'ILBM', 'BODY' );
  1914.  
  1915.             ret = ParseIFF( iff, IFFPARSE_SCAN );
  1916.  
  1917.             if(( ret == 0 ) || ( ret == IFFERR_EOF )) {
  1918.                 struct StoredProperty  *prop;
  1919.  
  1920.                 if( prop = FindProp( iff, 'ILBM', 'BMHD' )) {
  1921.                 UWORD   RowBytes;
  1922.                 ULONG   PlaneSize;
  1923.  
  1924.                 bmh = prop->sp_Data;
  1925.  
  1926.                 img->in_Width  = bmh->w;
  1927.                 img->in_Height = bmh->h;
  1928.                 img->in_Depth  = bmh->nPlanes;
  1929.  
  1930.                 RowBytes     = ((( img->in_Width + 15 ) & 0xFFF0 ) >> 3 );
  1931.                 PlaneSize    = RowBytes * img->in_Height;
  1932.                 img->in_Size = PlaneSize * img->in_Depth;
  1933.  
  1934.                 if( img->in_Data = AllocMem( img->in_Size, MEMF_CHIP | MEMF_CLEAR )) {
  1935.  
  1936.                     cn = CurrentChunk( iff );
  1937.  
  1938.                     if( cn->cn_ID == 'BODY' ) {
  1939.  
  1940.                     if( buf = AllocVec( cn->cn_Size, MEMF_CLEAR )) {
  1941.  
  1942.                         buf2 = buf;
  1943.  
  1944.                         ReadChunkBytes( iff, buf, cn->cn_Size );
  1945.  
  1946.                         switch( bmh->compression ) {
  1947.                         ULONG   c;
  1948.                         case 0:
  1949.                             for( c = 0; c < img->in_Height; c++ ) {
  1950.                             dest = img->in_Data;
  1951.  
  1952.                             ULONG   d;
  1953.                             for( d = 0; d < img->in_Depth; d++ ) {
  1954.                                 BYTE   *dest2;
  1955.  
  1956.                                 dest2 = dest + ( c * RowBytes );
  1957.  
  1958.                                 ULONG   e;
  1959.                                 for( e = 0; e < RowBytes; e++ )
  1960.                                 *dest2++ = *buf++;
  1961.  
  1962.                                 dest += PlaneSize;
  1963.                             }
  1964.                             }
  1965.                             ok = TRUE;
  1966.                             break;
  1967.  
  1968.                         case 1:
  1969.                             for( c = 0; c < img->in_Height; c++ ) {
  1970.                             ULONG   d;
  1971.  
  1972.                             dest = img->in_Data;
  1973.  
  1974.                             for( d = 0; d < img->in_Depth; d++ ) {
  1975.                                 BYTE   *dest2;
  1976.                                 ULONG   e;
  1977.  
  1978.                                 dest2 = dest + ( c * RowBytes );
  1979.  
  1980.                                 e = 0;
  1981.  
  1982.                                 do {
  1983.                                 BYTE    new;
  1984.  
  1985.                                 new = *buf++;
  1986.  
  1987.                                 if( new >= 0 ) {
  1988.                                     ULONG   f;
  1989.  
  1990.                                     new += 1;
  1991.                                     e   += new;
  1992.  
  1993.                                     for( f = 0; f < new; f++ )
  1994.                                     *dest2++ = *buf++;
  1995.  
  1996.                                 } else if( new != -128 ) {
  1997.                                     ULONG   f;
  1998.                                     BYTE    put;
  1999.  
  2000.                                     new  = -new + 1;
  2001.                                     e   += new;
  2002.                                     put  = *buf++;
  2003.  
  2004.                                     for( f = 0; f < new; f++ )
  2005.                                     *dest2++ = put;
  2006.                                 }
  2007.  
  2008.                                 } while( e < RowBytes );
  2009.  
  2010.                                 dest += PlaneSize;
  2011.                             }
  2012.                             }
  2013.                             ok = TRUE;
  2014.                             break;
  2015.  
  2016.                         default:
  2017.                             Stat("Unknown IFF-ILBM compression type!", TRUE, 0 );
  2018.                             break;
  2019.                         }
  2020.  
  2021.                         FreeVec( buf2 );
  2022.  
  2023.                         if( ok ) {
  2024.  
  2025.                         img->in_PlanePick = ( 0xFF >> ( 8 - img->in_Depth ));
  2026.  
  2027.                         AnalyseBitmap( img );
  2028.  
  2029.                         ClrImgSpace();
  2030.                         DrawImg( ImgBankWnd, img, 235, 1 );
  2031.                         RefreshWindowFrame( ImgBankWnd );
  2032.  
  2033.                         dest = img->in_Node.ln_Name = img->in_Label;
  2034.                         buf = ImageFile;
  2035.  
  2036.                         BYTE    new;
  2037.                         while( new = *buf++ ) {
  2038.                             if( new == '.' )
  2039.                             new = '_';
  2040.                             *dest++ = new;
  2041.                         }
  2042.                         *dest = '\0';
  2043.  
  2044.                         StaccaImgList();
  2045.                         AddTail((struct List *)&IE.Img_List, (struct Node *)img );
  2046.                         IB_ListTag[1] = IB_ListTag[3] = IE.NumImgs;
  2047.                         IE.NumImgs += 1;
  2048.                         AttaccaImgList();
  2049.  
  2050.                         IE.flags &= ~SALVATO;
  2051.  
  2052.                         if( IE.NumImgs == 1 ) {
  2053.                             DisableTag[1] = FALSE;
  2054.                             GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  2055.                                     NULL, (struct TagItem *)DisableTag );
  2056.                             GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Del ], ImgBankWnd,
  2057.                                     NULL, (struct TagItem *)DisableTag );
  2058.                             buffer2 = TRUE;
  2059.                         }
  2060.  
  2061.                         StringTag[1] = img->in_Node.ln_Name;
  2062.                         GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  2063.                                     NULL, (struct TagItem *)StringTag );
  2064.                         }
  2065.                     }
  2066.                     }
  2067.                 }
  2068.                 }
  2069.  
  2070.             } else
  2071.                 Stat( CatCompArray[ ERR_IOERR ].cca_Str, TRUE, ERR_IOERR );
  2072.  
  2073.             CloseIFF( iff );
  2074.             }
  2075.  
  2076.             Close( iff->iff_Stream );
  2077.  
  2078.         } else
  2079.             Stat( CatCompArray[ ERR_IOERR ].cca_Str, TRUE, ERR_IOERR );
  2080.  
  2081.         FreeIFF( iff );
  2082.  
  2083.         } else
  2084.         DisplayBeep( Scr );
  2085.     }
  2086.  
  2087.     if(!( ok )) {
  2088.         if( img->in_Data )
  2089.         FreeMem( img->in_Data, img->in_Size );
  2090.         FreeObject( img, IE_IMAGE );
  2091.     }
  2092.  
  2093.     } else
  2094.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, ERR_NOMEMORY );
  2095.  
  2096.     return( TRUE );
  2097. }
  2098.  
  2099. BOOL IB_ImgsKeyPressed( void )
  2100. {
  2101.     if(!( IDCMPMsg.Code & 0x20 )) {
  2102.     if( IB_ListTag[1] )
  2103.         IB_ListTag[1] -= 1;
  2104.     else
  2105.         IB_ListTag[1] = IE.NumImgs - 1;
  2106.     } else {
  2107.     if( IB_ListTag[1] < IE.NumImgs - 1 )
  2108.         IB_ListTag[1] += 1;
  2109.     else
  2110.         IB_ListTag[1] = 0;
  2111.     }
  2112.  
  2113.     IB_ListTag[3] = IDCMPMsg.Code = IB_ListTag[1];
  2114.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Imgs ], ImgBankWnd,
  2115.             NULL, (struct TagItem *)IB_ListTag );
  2116.  
  2117.     return( IB_ImgsClicked() );
  2118. }
  2119.  
  2120. BOOL IB_ImgsClicked( void )
  2121. {
  2122.     struct ImageNode   *img;
  2123.     int                 cnt;
  2124.  
  2125.     IB_ListTag[1] = IB_ListTag[3] = IDCMPMsg.Code;
  2126.  
  2127.     img = (struct ImageNode *)&IE.Img_List;
  2128.     for( cnt = 0; cnt <= IDCMPMsg.Code; cnt++ )
  2129.     img = img->in_Node.ln_Succ;
  2130.  
  2131.     ClrImgSpace();
  2132.     DrawImg( ImgBankWnd, img, 235, 1 );
  2133.     RefreshWindowFrame( ImgBankWnd );
  2134.  
  2135.     StringTag[1] = img->in_Node.ln_Name;
  2136.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  2137.             NULL, (struct TagItem *)StringTag );
  2138.  
  2139.     return( TRUE );
  2140. }
  2141.  
  2142. BOOL IB_LabelClicked( void )
  2143. {
  2144.     struct ImageNode   *img;
  2145.     int                 cnt;
  2146.  
  2147.     img = (struct ImageNode *)&IE.Img_List;
  2148.     for( cnt = 0; cnt <= IB_ListTag[1]; cnt++ )
  2149.     img = img->in_Node.ln_Succ;
  2150.  
  2151.     StaccaImgList();
  2152.     strcpy( img->in_Label, GetString( ImgBankGadgets[ GD_IB_Label ]) );
  2153.     AttaccaImgList();
  2154.  
  2155.     return( TRUE );
  2156. }
  2157.  
  2158. BOOL IB_DelKeyPressed( void )
  2159. {
  2160.     if( buffer2 )
  2161.     return( IB_DelClicked() );
  2162.     else
  2163.     return( TRUE );
  2164. }
  2165.  
  2166. BOOL IB_DelClicked( void )
  2167. {
  2168.     struct MenuTitle   *menu;
  2169.     struct _MenuItem   *item;
  2170.     struct MenuSub     *sub;
  2171.     struct BooleanInfo *gad;
  2172.     struct WindowInfo  *wnd;
  2173.     struct ImageNode   *img, *img2;
  2174.     struct Image       *image;
  2175.     struct WndImages   *wim;
  2176.     int                 cnt;
  2177.     BOOL                usata = FALSE;
  2178.     UWORD               old;
  2179.  
  2180.     img = (struct ImageNode *)&IE.Img_List;
  2181.     for( cnt = 0; cnt <= IB_ListTag[1]; cnt++ )
  2182.     img = img->in_Node.ln_Succ;
  2183.  
  2184.     if( old = IB_ListTag[1] ) {
  2185.     IB_ListTag[1] -= 1;
  2186.     IB_ListTag[3] = IB_ListTag[1];
  2187.     }
  2188.  
  2189.     image = &img->in_Left;
  2190.  
  2191.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ ) {
  2192.  
  2193.     for( wim = wnd->wi_Images.mlh_Head; wim->wim_Next; wim = wim->wim_Next ) {
  2194.         if( wim->wim_ImageNode == img )
  2195.         usata = TRUE;
  2196.     }
  2197.  
  2198.     for( gad = wnd->wi_Gadgets.mlh_Head; gad->b_Node.ln_Succ; gad = gad->b_Node.ln_Succ ) {
  2199.         if( gad->b_Kind == BOOLEAN ) {
  2200.         if(( gad->b_GadgetRender == image ) || ( gad->b_SelectRender == image ))
  2201.             usata = TRUE;
  2202.         }
  2203.     }
  2204.  
  2205.     for( menu = wnd->wi_Menus.mlh_Head; menu->mt_Node.ln_Succ; menu = menu->mt_Node.ln_Succ ) {
  2206.         for( item = menu->mt_Items.mlh_Head; item->min_Node.ln_Succ; item = item->min_Node.ln_Succ ) {
  2207.         if( item->min_Image == image )
  2208.             usata = TRUE;
  2209.         for( sub = item->min_Subs.mlh_Head; sub->msn_Node.ln_Succ; sub = sub->msn_Node.ln_Succ ) {
  2210.             if( sub->msn_Image == image )
  2211.             usata = TRUE;
  2212.         }
  2213.         }
  2214.     }
  2215.     }
  2216.  
  2217.     if( usata ) {
  2218.     if(!( IERequest( CatCompArray[ MSG_IMGUSED ].cca_Str,
  2219.              CatCompArray[ ANS_YES_NO  ].cca_Str,
  2220.              MSG_IMGUSED, ANS_YES_NO ))) {
  2221.  
  2222.         IB_ListTag[1] = IB_ListTag[3] = old;
  2223.         return( TRUE );
  2224.     }
  2225.  
  2226.         for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ ) {
  2227.  
  2228.         for( wim = wnd->wi_Images.mlh_Head; wim->wim_Next; wim = wim->wim_Next ) {
  2229.             if( wim->wim_ImageNode == img ) {
  2230.             Remove((struct Node *)wim );
  2231.             FreeObject( wim, IE_WNDIMAGE );
  2232.             }
  2233.         }
  2234.  
  2235.         for( gad = wnd->wi_Gadgets.mlh_Head; gad->b_Node.ln_Succ; gad = gad->b_Node.ln_Succ ) {
  2236.             if( gad->b_Kind == BOOLEAN ) {
  2237.  
  2238.             if( gad->b_GadgetRender == image )
  2239.                 gad->b_GadgetRender = NULL;
  2240.  
  2241.             if( gad->b_SelectRender == image )
  2242.                 gad->b_SelectRender = NULL;
  2243.             }
  2244.         }
  2245.  
  2246.         for( menu = wnd->wi_Menus.mlh_Head; menu->mt_Node.ln_Succ; menu = menu->mt_Node.ln_Succ ) {
  2247.             for( item = menu->mt_Items.mlh_Head; item->min_Node.ln_Succ; item = item->min_Node.ln_Succ ) {
  2248.  
  2249.             if( item->min_Image == image )
  2250.                 item->min_Image = NULL;
  2251.  
  2252.             for( sub = item->min_Subs.mlh_Head; sub->msn_Node.ln_Succ; sub = sub->msn_Node.ln_Succ ) {
  2253.                 if( sub->msn_Image == image )
  2254.                 sub->msn_Image = NULL;
  2255.             }
  2256.             }
  2257.         }
  2258.         }
  2259.     }
  2260.  
  2261.     img2 = img->in_Node.ln_Pred;
  2262.  
  2263.     if(!( img2->in_Node.ln_Pred ))
  2264.     img2 = img->in_Node.ln_Succ;
  2265.  
  2266.     StaccaImgList();
  2267.     Remove((struct Node *)img );
  2268.     AttaccaImgList();
  2269.  
  2270.     if( img->in_Data )
  2271.     FreeMem( img->in_Data, img->in_Size );
  2272.  
  2273.     FreeObject( img, IE_IMAGE );
  2274.  
  2275.     IE.NumImgs -= 1;
  2276.  
  2277.     ClrImgSpace();
  2278.  
  2279.     if( IE.NumImgs ) {
  2280.     DrawImg( ImgBankWnd, img2, 235, 1 );
  2281.  
  2282.     StringTag[1] = img2->in_Node.ln_Name;
  2283.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  2284.                 NULL, (struct TagItem *)StringTag );
  2285.     } else {
  2286.     DisableTag[1] = TRUE;
  2287.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Label ], ImgBankWnd,
  2288.                 NULL, (struct TagItem *)DisableTag );
  2289.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Del ], ImgBankWnd,
  2290.                 NULL, (struct TagItem *)DisableTag );
  2291.     buffer2 = FALSE;
  2292.     }
  2293.  
  2294.     IE.flags &= ~SALVATO;
  2295.  
  2296.     return( TRUE );
  2297. }
  2298.  
  2299. void StaccaImgList( void )
  2300. {
  2301.     ListTag[1] = NULL;
  2302.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Imgs ], ImgBankWnd,
  2303.             NULL, (struct TagItem *)ListTag );
  2304. }
  2305.  
  2306. void AttaccaImgList( void )
  2307. {
  2308.     ListTag[1] = &IE.Img_List;
  2309.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Imgs ], ImgBankWnd,
  2310.             NULL, (struct TagItem *)ListTag );
  2311.     GT_SetGadgetAttrsA( ImgBankGadgets[ GD_IB_Imgs ], ImgBankWnd,
  2312.             NULL, (struct TagItem *)IB_ListTag );
  2313. }
  2314. ///
  2315. /// Analyse Bitmap
  2316. void AnalyseBitmap( struct ImageNode *img )
  2317. {
  2318.     UBYTE   oldPP;
  2319.     ULONG   PlaneSize, elimina, oldsize;
  2320.     UWORD   RowBytes, resto, bytes, c, d, e;
  2321.     UBYTE   *ptr, *ptr2, *ptr3, new, mask2, mask, byte;
  2322.  
  2323.     oldPP       = img->in_PlanePick;
  2324.     PlaneSize   = img->in_Size / img->in_Depth;
  2325.     RowBytes    = (( img->in_Width + 15 ) & 0xFFF0 ) >> 3;
  2326.     resto       = img->in_Width % 8;
  2327.     bytes       = img->in_Width >> 3;
  2328.     mask2       = 0x01;
  2329.     elimina     = 0;
  2330.  
  2331.     if( resto )
  2332.     bytes -= 1;
  2333.  
  2334.     ptr3 = img->in_Data;
  2335.  
  2336.     for( c = 0; c < img->in_Depth; c++ ) {
  2337.     ptr = ptr3;
  2338.     new = *ptr;
  2339.  
  2340.     if(( new == 0 ) || ( new == 0xFF )) {
  2341.         for( d = 0; d < img->in_Height; d++ ) {
  2342.         ptr2 = ptr;
  2343.         for( e = 0; e < bytes; e++ ) {
  2344.             if( *ptr2++ != new )
  2345.             goto next_plane;
  2346.         }
  2347.  
  2348.         if( resto ) {
  2349.             mask = 0x80;
  2350.             byte = *ptr2;
  2351.             if( new ) {
  2352.             for( e = 0; e < resto; e++ ) {
  2353.                 if(!( byte & mask ))
  2354.                 goto next_plane;
  2355.                 mask >>= 1;
  2356.             }
  2357.             } else {
  2358.             for( e = 0; e < resto; e++ ) {
  2359.                 if( byte & mask )
  2360.                 goto next_plane;
  2361.                 mask >>= 1;
  2362.             }
  2363.             }
  2364.         }
  2365.  
  2366.         ptr += RowBytes;
  2367.         }
  2368.     } else {
  2369.         goto next_plane;
  2370.     }
  2371.  
  2372.     img->in_PlanePick  &= ~mask2;
  2373.  
  2374.     if( new )
  2375.         img->in_PlaneOnOff |=  mask2;
  2376.  
  2377.     elimina += PlaneSize;
  2378.  
  2379. next_plane:
  2380.     ptr3 += PlaneSize;
  2381.     mask2 <<= 1;
  2382.     }
  2383.  
  2384.     if( oldPP != img->in_PlanePick ) {
  2385.  
  2386.     ptr2 = ptr3 = img->in_Data;
  2387.     oldsize     = img->in_Size;
  2388.  
  2389.     if( img->in_Size - elimina ) {
  2390.         if( ptr = AllocMem( img->in_Size - elimina, MEMF_CHIP | MEMF_CLEAR )) {
  2391.  
  2392.         img->in_Data =  ptr;
  2393.         img->in_Size -= elimina;
  2394.  
  2395.         mask = 1;
  2396.         for( c = 0; c < img->in_Depth; c++ ) {
  2397.             if( img->in_PlanePick & mask ) {
  2398.             CopyMem( ptr3, ptr, PlaneSize );
  2399.             }
  2400.             ptr3 += PlaneSize;
  2401.             ptr  += PlaneSize;
  2402.             mask <<= 1;
  2403.         }
  2404.  
  2405.         } else {
  2406.         img->in_PlanePick = oldPP;
  2407.         return;
  2408.         }
  2409.     } else {
  2410.         img->in_Data = NULL;
  2411.         img->in_Size = 0L;
  2412.     }
  2413.     FreeMem( ptr2, oldsize );
  2414.     }
  2415. }
  2416. ///
  2417. /// Draw Img & ClearImgSpace
  2418. void DrawImg( struct Window *wnd, struct ImageNode *img, WORD x, WORD y )
  2419. {
  2420.     DrawImage( wnd->RPort, (struct Image *)&img->in_Left, x, y + YOffset );
  2421. }
  2422.  
  2423. void ClrImgSpace( void )
  2424. {
  2425.     EraseRect( ImgBankWnd->RPort, 235, YOffset + 1,
  2426.            ImgBankWnd->Width - Scr->WBorRight - 1,
  2427.            ImgBankWnd->Height - Scr->WBorBottom - 1 );
  2428. }
  2429. ///
  2430. /// FreeImgList
  2431. void FreeImgList( void )
  2432. {
  2433.     struct ImageNode   *img;
  2434.  
  2435.     while( img = RemTail((struct List *)&IE.Img_List )) {
  2436.     if( img->in_Data )
  2437.         FreeMem( img->in_Data, img->in_Size );
  2438.     FreeObject( img, IE_IMAGE );
  2439.     }
  2440.  
  2441.     IE.NumImgs = 0;
  2442. }
  2443. ///
  2444.